home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / bavarian / 071-080 / 078_filme / simp-anim / simpanim.c < prev    next >
C/C++ Source or Header  |  1993-11-04  |  16KB  |  582 lines
  1. /*****************************************************************************/
  2. /*           Simple Animation without using the Amiga GELS system            */
  3. /*   July 13th 1987. By Steven E. Jacobs of Charlotte Amiga Users Group.     */
  4. /*---------------------------------------------------------------------------*/
  5. /*   This program shows how to implement SIMPLE Animation using DrawImage,   */
  6. /* DrawEllipse and ClipBlit. A Super Bitmap window is opened as well as      */
  7. /* an Off Screen Raster. This allows for drawing images 'Off Screen' and     */
  8. /* then clipping the image to the window viewing area. The advantage to      */
  9. /* this is that if the image (ellipse, etc) was drawn directly to the On     */
  10. /* Screen area you would have to erase that area before redrawing the image  */
  11. /* (except when using DrawImage), which would cause the animated image to    */
  12. /* flicker. By drawing the ellipses, etc. to the Off Screen Rast Port you    */
  13. /* can Clip or transfer the image directly to the On Screen Viewing area     */
  14. /* in a manner similar to DrawImage. The Previous area in the On Screen area */
  15. /* is completely redrawn over by the new clipping. This eliminates the       */
  16. /* requirement of erasing the area with RectFill type commands therefore     */
  17. /* eliminating the flicker.                                                  */
  18. /*                                                                           */
  19. /* 1- The first animation is a hoop (ellipse) that is rotating. The actual   */
  20. /*    ellipse image is drawn ONE time on the Off Screen area then clipped    */
  21. /*    to FOUR different areas on the On Screen viewing area. The ellipse     */
  22. /*    image is then erased from the Off Screen area and the next image in    */
  23. /*    the animation sequence is drawn. This process repeats itself from      */
  24. /*    within for/next loops.                                                 */
  25. /* 2- The Second animation sequence (Bird flapping wings) does NOT use the   */
  26. /*    Off Screen Rast Port but uses a simpler method using the Intuition     */
  27. /*    Command 'DrawImage'. The Images that are drawn in sequence are defined */
  28. /*    with the Program.                                                      */
  29. /* 3- The Third Animation Sequence (A Lot of birds flapping Wings) Draws the */
  30. /*    8 animation frames to the Off Screen Rast Port, Then Clips them One    */
  31. /*    at a time to the On Screen Rast Port (viewing area) in multiple        */
  32. /*    positions. The Animation frames are drawn ONE time each and Clipped    */
  33. /*    Several times each to create the animation.                            */
  34. /*                                                                           */
  35. /* I am sure there are other alternative ways to create and display such     */
  36. /* animations. These are only a few requiring LITTLE OVERHEAD which makes    */
  37. /* them usefull as alternatives for applications that require basic          */
  38. /* animation sequences or 'Wire Frame' type applications. The techniques     */
  39. /* shown above are not limited to 4 colors, rather to the programmers needs  */
  40. /* and memory restrictions. I hope that these 'BASIC' techniques have been   */
  41. /* usefull.                                                                  */
  42. /*                                       Steve Jacobs                        */
  43. /*                                                                           */
  44. /*****************************************************************************/
  45.  
  46. #include <exec/types.h>
  47. #include <intuition/intuition.h>
  48. #include <graphics/gfxmacros.h>
  49.  
  50. struct IntuitionBase *IntuitionBase;
  51. struct GfxBase *GfxBase;
  52. struct Window *Wdw;
  53. struct ViewPort *WVP;
  54.  
  55. #define DEPTH 2                               /* Depth of OffScreen Bitmap.  */
  56. #define WIDTH 640                             /* Width of OffScreen Bitmap.  */
  57. #define HEIGHT 200                            /* Height of OffScreen Bitmap. */
  58.  
  59. VOID drawellipse(),animatebird(),delay(),clipbird(),main();
  60.  
  61. int x,t,c,y,i,j;                              /* Loop Variables Used         */
  62.  
  63. extern PLANEPTR AllocRaster();                /* Set Up structures and       */
  64.                                               /* Pointers needed for the     */
  65. struct BitMap myBitM;                         /* Off Screen Drawing area.    */     
  66. struct RastPort myRast;                       /* Off Screen Raster Port.     */
  67. struct RastPort *Rp;                          /* Pointer to On Screen Rast   */
  68. struct RastPort *osRp;                        /* Pointer to Off Screen Rast  */
  69.  
  70.       /* Bird Animation Frames f1 thru f8. Eight frames total! */
  71.  
  72. UWORD f1ImageData[48] = {
  73.     /* BitPlane 0 */
  74.    0x0000,0x1000,
  75.    0x0000,0x7800,
  76.    0x0001,0xF800,
  77.    0x1C07,0xF800,
  78.    0xEF1F,0xF000,
  79.    0x1FFF,0xE000,
  80.    0x03FF,0xC000,
  81.    0x01FF,0xE000,
  82.    0x007F,0xFFFC,
  83.    0x000F,0xFF80,
  84.    0x0000,0x8000,
  85.    0x0001,0x4000,
  86.     /* BitPlane 1 */
  87.    0x0000,0x0000,
  88.    0x0000,0x1000,
  89.    0x0000,0x7000,
  90.    0x0000,0xF000,
  91.    0x0003,0xC000,
  92.    0x000F,0xC000,
  93.    0x007F,0x8000,
  94.    0x003F,0x0000,
  95.    0x0000,0x0000,
  96.    0x0000,0x0000,
  97.    0x0000,0x0000,
  98.    0x0000,0x0000
  99. };
  100.  
  101. struct Image f1Image = {
  102.     0, 0,         /* LeftEdge, TopEdge     */
  103.     30, 12, 2,     /* Width, Height, Depth  */
  104.     &f1ImageData[0], /* ImageData             */
  105.     0x03, 0x00,     /* PlanePick, PlaneOnOff */
  106.     NULL         /* NextImage             */
  107. };
  108.  
  109. UWORD f2ImageData[48] = {
  110.     /* BitPlane 0 */
  111.    0x0000,0x0000,
  112.    0x0000,0x7000,
  113.    0x0001,0xF800,
  114.    0x1C07,0xF800,
  115.    0xEF1F,0xF000,
  116.    0x1FFF,0xE000,
  117.    0x03FF,0xC000,
  118.    0x01FF,0xE000,
  119.    0x007F,0xFFFC,
  120.    0x000F,0xFF80,
  121.    0x0000,0x8000,
  122.    0x0001,0x4000,
  123.     /* BitPlane 1 */
  124.    0x0000,0x0000,
  125.    0x0000,0x0000,
  126.    0x0000,0x7000,
  127.    0x0000,0xF000,
  128.    0x0003,0xC000,
  129.    0x000F,0xC000,
  130.    0x007F,0x8000,
  131.    0x003F,0x0000,
  132.    0x0000,0x0000,
  133.    0x0000,0x0000,
  134.    0x0000,0x0000,
  135.    0x0000,0x0000
  136. };
  137.  
  138. struct Image f2Image = {
  139.     0, 0,
  140.     30, 12, 2,
  141.     &f2ImageData[0],
  142.     0x03, 0x00,
  143.     NULL
  144. };
  145.  
  146. UWORD f3ImageData[48] = {
  147.     /* BitPlane 0 */
  148.    0x0000,0x0000,
  149.    0x0000,0x0000,
  150.    0x0000,0x7000,
  151.    0x1C01,0xF800,
  152.    0xEF0F,0xF000,
  153.    0x1FFF,0xE000,
  154.    0x03FF,0xC000,
  155.    0x01FF,0xC000,
  156.    0x007F,0xFFFC,
  157.    0x000F,0xFF80,
  158.    0x0000,0x8000,
  159.    0x0001,0x4000,
  160.     /* BitPlane 1 */
  161.    0x0000,0x0000,
  162.    0x0000,0x0000,
  163.    0x0000,0x0000,
  164.    0x0000,0x7000,
  165.    0x0003,0xC000,
  166.    0x000F,0xC000,
  167.    0x007F,0x8000,
  168.    0x003F,0x0000,
  169.    0x0000,0x0000,
  170.    0x0000,0x0000,
  171.    0x0000,0x0000,
  172.    0x0000,0x0000
  173. };
  174.  
  175. struct Image f3Image = {
  176.     0, 0,
  177.     30, 12, 2,
  178.     &f3ImageData[0],
  179.     0x03, 0x00,
  180.     NULL
  181. };
  182.  
  183. UWORD f4ImageData[48] = {
  184.     /* BitPlane 0 */
  185.    0x0000,0x0000,
  186.    0x0000,0x0000,
  187.    0x0000,0x0000,
  188.    0x1C01,0xE000,
  189.    0xEF0F,0xE000,
  190.    0x1FFF,0xC000,
  191.    0x03FF,0xC000,
  192.    0x01FF,0xC000,
  193.    0x007F,0xFFFC,
  194.    0x000F,0xFF80,
  195.    0x0000,0x8000,
  196.    0x0001,0x4000,
  197.     /* BitPlane 1 */
  198.    0x0000,0x0000,
  199.    0x0000,0x0000,
  200.    0x0000,0x0000,
  201.    0x0000,0x0000,
  202.    0x0000,0x8000,
  203.    0x000F,0x8000,
  204.    0x007F,0x8000,
  205.    0x003F,0x0000,
  206.    0x0000,0x0000,
  207.    0x0000,0x0000,
  208.    0x0000,0x0000,
  209.    0x0000,0x0000
  210. };
  211.  
  212. struct Image f4Image = {
  213.     0, 0,
  214.     30, 12, 2,
  215.     &f4ImageData[0],
  216.     0x03, 0x00,
  217.     NULL
  218. };
  219.  
  220. UWORD f5ImageData[48] = {
  221.     /* BitPlane 0 */
  222.    0x0000,0x0000,
  223.    0x0000,0x0000,
  224.    0x0000,0x0000,
  225.    0x1C00,0x0000,
  226.    0xEF00,0x8000,
  227.    0x1FFF,0xC000,
  228.    0x03FF,0xC000,
  229.    0x01FF,0xF000,
  230.    0x007F,0xFFFC,
  231.    0x000F,0xFF80,
  232.    0x0000,0x8000,
  233.    0x0001,0x4000,
  234.     /* BitPlane 1 */
  235.    0x0000,0x0000,
  236.    0x0000,0x0000,
  237.    0x0000,0x0000,
  238.    0x0000,0x0000,
  239.    0x0000,0x0000,
  240.    0x0000,0x8000,
  241.    0x007F,0x8000,
  242.    0x003F,0x0000,
  243.    0x0000,0x0000,
  244.    0x0000,0x0000,
  245.    0x0000,0x0000,
  246.    0x0000,0x0000
  247. };
  248.  
  249. struct Image f5Image = {
  250.     0, 0,
  251.     30, 12, 2,
  252.     &f5ImageData[0],
  253.     0x03, 0x00,
  254.     NULL
  255. };
  256.  
  257. UWORD f6ImageData[48] = {
  258.     /* BitPlane 0 */
  259.    0x0000,0x0000,
  260.    0x0000,0x0000,
  261.    0x0000,0x0000,
  262.    0x1C00,0x0000,
  263.    0xEF00,0x0000,
  264.    0x1FDF,0xC000,
  265.    0x03FB,0xA000,
  266.    0x01FE,0x7800,
  267.    0x007F,0xFFFC,
  268.    0x000F,0xFF80,
  269.    0x0000,0x8000,
  270.    0x0001,0x4000,
  271.     /* BitPlane 1 */
  272.    0x0000,0x0000,
  273.    0x0000,0x0000,
  274.    0x0000,0x0000,
  275.    0x0000,0x0000,
  276.    0x0000,0x0000,
  277.    0x0000,0x0000,
  278.    0x0078,0x0000,
  279.    0x003E,0x0000,
  280.    0x0000,0x0000,
  281.    0x0000,0x0000,
  282.    0x0000,0x0000,
  283.    0x0000,0x0000
  284. };
  285.  
  286. struct Image f6Image = {
  287.     0, 0,
  288.     30, 12, 2,
  289.     &f6ImageData[0],
  290.     0x03, 0x00,
  291.     NULL
  292. };
  293.  
  294. UWORD f7ImageData[48] = {
  295.     /* BitPlane 0 */
  296.    0x0000,0x0000,
  297.    0x0000,0x0000,
  298.    0x0000,0x0000,
  299.    0x1C00,0x0000,
  300.    0xEF00,0x0000,
  301.    0x1F9F,0xC000,
  302.    0x03CF,0x2000,
  303.    0x01E6,0x780C,
  304.    0x0079,0xFFF0,
  305.    0x000F,0xFF80,
  306.    0x0000,0x8000,
  307.    0x0001,0x4000,
  308.     /* BitPlane 1 */
  309.    0x0000,0x0000,
  310.    0x0000,0x0000,
  311.    0x0000,0x0000,
  312.    0x0000,0x0000,
  313.    0x0000,0x0000,
  314.    0x0000,0x0000,
  315.    0x0040,0x0000,
  316.    0x0020,0x0000,
  317.    0x0000,0x0000,
  318.    0x0000,0x0000,
  319.    0x0000,0x0000,
  320.    0x0000,0x0000
  321. };
  322.  
  323. struct Image f7Image = {
  324.     0, 0,
  325.     30, 12, 2,
  326.     &f7ImageData[0],
  327.     0x03, 0x00,
  328.     NULL
  329. };
  330.  
  331. UWORD f8ImageData[48] = {
  332.     /* BitPlane 0 */
  333.    0x0000,0x0000,
  334.    0x0000,0x0000,
  335.    0x0000,0x0000,
  336.    0x1C00,0x0000,
  337.    0xEF00,0x0000,
  338.    0x1F3F,0xC000,
  339.    0x039F,0x9000,
  340.    0x01CF,0x380C,
  341.    0x006E,0x7FF0,
  342.    0x0009,0xFF80,
  343.    0x0000,0x8000,
  344.    0x0001,0x4000,
  345.     /* BitPlane 1 */
  346.    0x0000,0x0000,
  347.    0x0000,0x0000,
  348.    0x0000,0x0000,
  349.    0x0000,0x0000,
  350.    0x0000,0x0000,
  351.    0x0000,0x0000,
  352.    0x0000,0x0000,
  353.    0x0000,0x0000,
  354.    0x0000,0x0000,
  355.    0x0000,0x0000,
  356.    0x0000,0x0000,
  357.    0x0000,0x0000
  358. };
  359.  
  360. struct Image f8Image = {
  361.     0, 0,
  362.     30, 12, 2,
  363.     &f8ImageData[0],
  364.     0x03, 0x00,
  365.     NULL
  366. };
  367.  
  368. struct NewWindow NewWdw =
  369.    {
  370.    0,0,
  371.    640,200,
  372.    0,1,
  373.    NULL,
  374.    WINDOWDEPTH | ACTIVATE | SUPER_BITMAP, /* NOTE SUPER_BITMAP */
  375.    NULL,
  376.    NULL,
  377.    " SIMPLE Animations in 'C' without using GELS. By Steven E. Jacobs, CAUG ",
  378.    NULL,
  379.    NULL,
  380.    227,50,
  381.    0,0,
  382.    WBENCHSCREEN
  383.    };
  384.  
  385. VOID main()
  386. {
  387.    IntuitionBase = (struct IntuitionBase *)
  388.         OpenLibrary("intuition.library",LIBRARY_VERSION);
  389.    if (IntuitionBase == NULL)
  390.          { printf("This program requires KickStart & WorkBench 1.2 to run!\n");
  391.            exit(FALSE); };
  392.  
  393.    GfxBase = (struct GfxBase *)
  394.         OpenLibrary("graphics.library",LIBRARY_VERSION);
  395.    if (GfxBase == NULL)
  396.          { printf("Unable to open Graphics.Library.\n");
  397.            CloseLibrary(IntuitionBase);
  398.            exit(FALSE); };
  399.  
  400.    if (( Wdw = (struct Window *)OpenWindow(&NewWdw)) == NULL)
  401.          { printf("Unable to open window.\,");
  402.            CloseLibrary(GfxBase);
  403.            CloseLibrary(IntuitionBase);
  404.            exit(FALSE);
  405.          };
  406.  
  407.    Rp = Wdw->RPort;  /* Not that window is open assign On Screen Rast Port! */
  408.  
  409.                      /* Set Up and Initialize Bitmap for off screen drawing */
  410.  
  411.    InitBitMap(&myBitM,DEPTH,WIDTH,HEIGHT);
  412.     for(i=0;i<DEPTH;i++)
  413.      {
  414.       myBitM.Planes[i] = AllocRaster(WIDTH,HEIGHT);
  415.        if(myBitM.Planes[i]==0)      /* Oh No! Not Enough Memory. Cancel it! */
  416.          {
  417.           printf("Not Enough Memory!\n");
  418.           CloseWindow(Wdw);
  419.           CloseLibrary(GfxBase);
  420.           CloseLibrary(IntuitionBase);
  421.           exit(FALSE);
  422.          };
  423.      };
  424.        InitRastPort(&myRast);        /* Initialize the RastPort and link it */
  425.        myRast.BitMap = &myBitM;      /* to the BitMap! (Off Screen)         */
  426.        osRp = &myRast;               /* assign it to easy to type in Var.   */
  427.  
  428. drawellipse();
  429. animatebird();
  430. drawellipse();
  431. animatebird();
  432. animatebird();
  433. clipbird();
  434. clipbird();
  435. delay(500000);
  436.  
  437.  if(Wdw) CloseWindow(Wdw);
  438.  if(GfxBase) CloseLibrary(GfxBase);
  439.  if(IntuitionBase) CloseLibrary(IntuitionBase);
  440.                                                 /* De-Allocate SuperBitmap! */
  441.  for(i=0;i<DEPTH;i++)
  442.   {
  443.    if(myBitM.Planes[i] != 0)
  444.     {
  445.      FreeRaster(myBitM.Planes[i],WIDTH,HEIGHT);
  446.     };
  447.   };
  448.  exit(0);                                                 /* Exit Program!! */
  449. }
  450.  
  451. VOID drawellipse()
  452. {
  453.  Move(Rp,140,17);
  454.  Text(Rp,"Displaying Four Ellipses from ONE Clip!!!",41);
  455.                         /*    Start Drawing ellipses for simple animation   */
  456. SetRast(osRp,0);                         /* Blank out Off Screen Rast Port! */
  457.  
  458. for(c=0;c<2;c++)        /* Here are the SIMPLE graphic routines in loops!   */
  459.  {
  460.   for(x=2;x<100;x=x+2)
  461.    {
  462.     SetAPen(osRp,1);   /* Set the Drawing Pen to color 1 (Off Screen BitMap)*/
  463.     DrawEllipse(osRp,320,100,x,25);        /* Now Draw an Invisible Ellipse */
  464.     ClipBlit(osRp,200,75,Rp,35,20,250,55,0xc0);   /* Transfer it to Viewing */
  465.     ClipBlit(osRp,200,75,Rp,355,20,250,55,0xc0);  /* On Screen BitMap NOT   */
  466.     ClipBlit(osRp,200,75,Rp,35,120,250,55,0xc0);  /* once but 4 times!      */
  467.     ClipBlit(osRp,200,75,Rp,355,120,250,55,0xc0); /* Draw 1 Display 4.      */
  468.     SetRast(osRp,0);                              /* Clear the Off Screen   */
  469.    };                                             /* Rast Port now.         */
  470.  
  471.   for(y=25;y>1;y=y-1)                       /* Repeat, Repeat, & Repeat!!!! */
  472.    {
  473.     SetAPen(osRp,1);
  474.     DrawEllipse(osRp,320,100,100,y);
  475.     ClipBlit(osRp,200,75,Rp,35,20,250,55,0xc0); /* Drawing once and clipping*/
  476.     ClipBlit(osRp,200,75,Rp,355,20,250,55,0xc0);/* 4 times is MY way of     */
  477.     ClipBlit(osRp,200,75,Rp,35,120,250,55,0xc0);/* showing flexability here */
  478.     ClipBlit(osRp,200,75,Rp,355,120,250,55,0xc0);
  479.     SetRast(osRp,0);     
  480.    };
  481.  
  482.   for(y=1;y<25;y=y+1)
  483.    {
  484.     SetAPen(osRp,2);
  485.     DrawEllipse(osRp,320,100,100,y);
  486.     ClipBlit(osRp,200,75,Rp,35,20,250,55,0xc0);
  487.     ClipBlit(osRp,200,75,Rp,355,20,250,55,0xc0);
  488.     ClipBlit(osRp,200,75,Rp,35,120,250,55,0xc0);
  489.     ClipBlit(osRp,200,75,Rp,355,120,250,55,0xc0);
  490.     SetRast(osRp,0);     
  491.    };
  492.  
  493.   for(x=100;x>3;x=x-2)
  494.    {
  495.     SetAPen(osRp,2);
  496.     DrawEllipse(osRp,320,100,x,25);
  497.     ClipBlit(osRp,200,75,Rp,35,20,250,55,0xc0);
  498.     ClipBlit(osRp,200,75,Rp,355,20,250,55,0xc0);
  499.     ClipBlit(osRp,200,75,Rp,35,120,250,55,0xc0);
  500.     ClipBlit(osRp,200,75,Rp,355,120,250,55,0xc0);
  501.     SetRast(osRp,0);     
  502.    };
  503.  };
  504.  
  505.                                               /* Ellipse Animation complete */
  506. }
  507.  
  508. VOID animatebird()
  509. {
  510.  int loops;
  511.  Move(Rp,140,17);
  512.  Text(Rp,"Displaying a single Animation w/DrawImage",41);
  513.  for(loops=0;loops<40;loops++)
  514.   {
  515.    DrawImage(Rp,&f1Image,300,90);delay(1500);
  516.    DrawImage(Rp,&f2Image,300,90);delay(1500);
  517.    DrawImage(Rp,&f3Image,300,90);delay(1500);
  518.    DrawImage(Rp,&f4Image,300,90);delay(1500);
  519.    DrawImage(Rp,&f5Image,300,90);delay(1500);
  520.    DrawImage(Rp,&f6Image,300,90);delay(1500);
  521.    DrawImage(Rp,&f7Image,300,90);delay(1500);
  522.    DrawImage(Rp,&f8Image,300,90);delay(1500);
  523.    DrawImage(Rp,&f7Image,300,90);delay(1500);
  524.    DrawImage(Rp,&f6Image,300,90);delay(1500);
  525.    DrawImage(Rp,&f5Image,300,90);delay(1500);
  526.    DrawImage(Rp,&f4Image,300,90);delay(1500);
  527.    DrawImage(Rp,&f3Image,300,90);delay(1500);
  528.    DrawImage(Rp,&f2Image,300,90);delay(1500);
  529.   }
  530. }
  531.  
  532.  
  533. VOID delay(factor)
  534. int factor;
  535. {
  536.  int loops;
  537.  for(loops=0;loops<factor;loops++);
  538. }
  539.  
  540. VOID clipbird()
  541. {
  542.  int x1,y1,wid,hei,x2,fx1,howmany,frame;
  543.  Move(Rp,140,17);
  544.  Text(Rp,"Displaying Multiple Images from ONE Clip!",41);
  545.  x1=30;
  546.  y1=180;
  547.  wid=30;
  548.  hei=12;
  549.                       /* Draw the animation images to the OS Rast Port ONCE! */
  550.  DrawImage(osRp,&f1Image,x1 * 1,y1);
  551.  DrawImage(osRp,&f2Image,x1 * 2,y1);
  552.  DrawImage(osRp,&f3Image,x1 * 3,y1);
  553.  DrawImage(osRp,&f4Image,x1 * 4,y1);
  554.  DrawImage(osRp,&f5Image,x1 * 5,y1);
  555.  DrawImage(osRp,&f6Image,x1 * 6,y1);
  556.  DrawImage(osRp,&f7Image,x1 * 7,y1);
  557.  DrawImage(osRp,&f8Image,x1 * 8,y1);
  558.  
  559. for(howmany=0;howmany<20;howmany++)        /* Howmany times do we do this? */
  560.  {
  561.   for(frame=1;frame<9;frame++)            /* forward 8 frames */
  562.    {
  563.     fx1 = frame * 30;
  564.     for(x2=30;x2<590;x2=x2+30)
  565.      {
  566.         ClipBlit(osRp,fx1,y1,Rp,x2,y1,wid,hei,0xc0);   /* Clip it over!!  */
  567.      }
  568.    }
  569.   for(frame=8;frame>1;frame-=1)           /* Reverse 8 frames */
  570.    {
  571.     fx1 = frame * 30;
  572.     for(x2=30;x2<590;x2=x2+30)
  573.      {
  574.         ClipBlit(osRp,fx1,y1,Rp,x2,y1,wid,hei,0xc0);   /* Clip it over!!  */
  575.      }
  576.    }
  577.  } /* end of howmany loops */
  578. } /* End of ClipBird */
  579.  
  580.               /* End of the Graphics Clipping Example! */
  581.  
  582.